// Copyright 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/process/process.h"

#include <errno.h>
#include <stdint.h>
#include <sys/resource.h>
#include <sys/wait.h>

#include "base/files/scoped_file.h"
#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#include "base/process/kill.h"
#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
#include "build/build_config.h"

#if defined(OS_MACOSX)
#include <sys/event.h>
#endif

namespace {

#if !defined(OS_NACL_NONSFI)

bool WaitpidWithTimeout(base::ProcessHandle handle,
    int* status,
    base::TimeDelta wait)
{
    // This POSIX version of this function only guarantees that we wait no less
    // than |wait| for the process to exit.  The child process may
    // exit sometime before the timeout has ended but we may still block for up
    // to 256 milliseconds after the fact.
    //
    // waitpid() has no direct support on POSIX for specifying a timeout, you can
    // either ask it to block indefinitely or return immediately (WNOHANG).
    // When a child process terminates a SIGCHLD signal is sent to the parent.
    // Catching this signal would involve installing a signal handler which may
    // affect other parts of the application and would be difficult to debug.
    //
    // Our strategy is to call waitpid() once up front to check if the process
    // has already exited, otherwise to loop for |wait|, sleeping for
    // at most 256 milliseconds each time using usleep() and then calling
    // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
    // we double it every 4 sleep cycles.
    //
    // usleep() is speced to exit if a signal is received for which a handler
    // has been installed.  This means that when a SIGCHLD is sent, it will exit
    // depending on behavior external to this function.
    //
    // This function is used primarily for unit tests, if we want to use it in
    // the application itself it would probably be best to examine other routes.

    if (wait == base::TimeDelta::Max()) {
        return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
    }

    pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
    static const int64_t kMaxSleepInMicroseconds = 1 << 18; // ~256 milliseconds.
    int64_t max_sleep_time_usecs = 1 << 10; // ~1 milliseconds.
    int64_t double_sleep_time = 0;

    // If the process hasn't exited yet, then sleep and try again.
    base::TimeTicks wakeup_time = base::TimeTicks::Now() + wait;
    while (ret_pid == 0) {
        base::TimeTicks now = base::TimeTicks::Now();
        if (now > wakeup_time)
            break;
        // Guaranteed to be non-negative!
        int64_t sleep_time_usecs = (wakeup_time - now).InMicroseconds();
        // Sleep for a bit while we wait for the process to finish.
        if (sleep_time_usecs > max_sleep_time_usecs)
            sleep_time_usecs = max_sleep_time_usecs;

        // usleep() will return 0 and set errno to EINTR on receipt of a signal
        // such as SIGCHLD.
        usleep(sleep_time_usecs);
        ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));

        if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) && (double_sleep_time++ % 4 == 0)) {
            max_sleep_time_usecs *= 2;
        }
    }

    return ret_pid > 0;
}

#if defined(OS_MACOSX)
// Using kqueue on Mac so that we can wait on non-child processes.
// We can't use kqueues on child processes because we need to reap
// our own children using wait.
static bool WaitForSingleNonChildProcess(base::ProcessHandle handle,
    base::TimeDelta wait)
{
    DCHECK_GT(handle, 0);
    DCHECK_GT(wait, base::TimeDelta());

    base::ScopedFD kq(kqueue());
    if (!kq.is_valid()) {
        DPLOG(ERROR) << "kqueue";
        return false;
    }

    struct kevent change = { 0 };
    EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
    int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
    if (result == -1) {
        if (errno == ESRCH) {
            // If the process wasn't found, it must be dead.
            return true;
        }

        DPLOG(ERROR) << "kevent (setup " << handle << ")";
        return false;
    }

    // Keep track of the elapsed time to be able to restart kevent if it's
    // interrupted.
    bool wait_forever = (wait == base::TimeDelta::Max());
    base::TimeDelta remaining_delta;
    base::TimeTicks deadline;
    if (!wait_forever) {
        remaining_delta = wait;
        deadline = base::TimeTicks::Now() + remaining_delta;
    }

    result = -1;
    struct kevent event = { 0 };

    while (wait_forever || remaining_delta > base::TimeDelta()) {
        struct timespec remaining_timespec;
        struct timespec* remaining_timespec_ptr;
        if (wait_forever) {
            remaining_timespec_ptr = NULL;
        } else {
            remaining_timespec = remaining_delta.ToTimeSpec();
            remaining_timespec_ptr = &remaining_timespec;
        }

        result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);

        if (result == -1 && errno == EINTR) {
            if (!wait_forever) {
                remaining_delta = deadline - base::TimeTicks::Now();
            }
            result = 0;
        } else {
            break;
        }
    }

    if (result < 0) {
        DPLOG(ERROR) << "kevent (wait " << handle << ")";
        return false;
    } else if (result > 1) {
        DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
                    << result;
        return false;
    } else if (result == 0) {
        // Timed out.
        return false;
    }

    DCHECK_EQ(result, 1);

    if (event.filter != EVFILT_PROC || (event.fflags & NOTE_EXIT) == 0 || event.ident != static_cast<uintptr_t>(handle)) {
        DLOG(ERROR) << "kevent (wait " << handle
                    << "): unexpected event: filter=" << event.filter
                    << ", fflags=" << event.fflags
                    << ", ident=" << event.ident;
        return false;
    }

    return true;
}
#endif // OS_MACOSX

bool WaitForExitWithTimeoutImpl(base::ProcessHandle handle,
    int* exit_code,
    base::TimeDelta timeout)
{
    base::ProcessHandle parent_pid = base::GetParentProcessId(handle);
    base::ProcessHandle our_pid = base::GetCurrentProcessHandle();
    if (parent_pid != our_pid) {
#if defined(OS_MACOSX)
        // On Mac we can wait on non child processes.
        return WaitForSingleNonChildProcess(handle, timeout);
#else
        // Currently on Linux we can't handle non child processes.
        NOTIMPLEMENTED();
#endif // OS_MACOSX
    }

    int status;
    if (!WaitpidWithTimeout(handle, &status, timeout))
        return false;
    if (WIFSIGNALED(status)) {
        if (exit_code)
            *exit_code = -1;
        return true;
    }
    if (WIFEXITED(status)) {
        if (exit_code)
            *exit_code = WEXITSTATUS(status);
        return true;
    }
    return false;
}
#endif // !defined(OS_NACL_NONSFI)

} // namespace

namespace base {

Process::Process(ProcessHandle handle)
    : process_(handle)
{
}

Process::~Process()
{
}

Process::Process(Process&& other)
    : process_(other.process_)
{
    other.Close();
}

Process& Process::operator=(Process&& other)
{
    DCHECK_NE(this, &other);
    process_ = other.process_;
    other.Close();
    return *this;
}

// static
Process Process::Current()
{
    return Process(GetCurrentProcessHandle());
}

// static
Process Process::Open(ProcessId pid)
{
    if (pid == GetCurrentProcId())
        return Current();

    // On POSIX process handles are the same as PIDs.
    return Process(pid);
}

// static
Process Process::OpenWithExtraPrivileges(ProcessId pid)
{
    // On POSIX there are no privileges to set.
    return Open(pid);
}

// static
Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle)
{
    DCHECK_NE(handle, GetCurrentProcessHandle());
    return Process(handle);
}

#if !defined(OS_LINUX)
// static
bool Process::CanBackgroundProcesses()
{
    return false;
}
#endif // !defined(OS_LINUX)

bool Process::IsValid() const
{
    return process_ != kNullProcessHandle;
}

ProcessHandle Process::Handle() const
{
    return process_;
}

Process Process::Duplicate() const
{
    if (is_current())
        return Current();

    return Process(process_);
}

ProcessId Process::Pid() const
{
    DCHECK(IsValid());
    return GetProcId(process_);
}

bool Process::is_current() const
{
    return process_ == GetCurrentProcessHandle();
}

void Process::Close()
{
    process_ = kNullProcessHandle;
    // if the process wasn't terminated (so we waited) or the state
    // wasn't already collected w/ a wait from process_utils, we're gonna
    // end up w/ a zombie when it does finally exit.
}

#if !defined(OS_NACL_NONSFI)
bool Process::Terminate(int exit_code, bool wait) const
{
    // exit_code isn't supportable.
    DCHECK(IsValid());
    CHECK_GT(process_, 0);

    bool result = kill(process_, SIGTERM) == 0;
    if (result && wait) {
        int tries = 60;

        if (RunningOnValgrind()) {
            // Wait for some extra time when running under Valgrind since the child
            // processes may take some time doing leak checking.
            tries *= 2;
        }

        unsigned sleep_ms = 4;

        // The process may not end immediately due to pending I/O
        bool exited = false;
        while (tries-- > 0) {
            pid_t pid = HANDLE_EINTR(waitpid(process_, NULL, WNOHANG));
            if (pid == process_) {
                exited = true;
                break;
            }
            if (pid == -1) {
                if (errno == ECHILD) {
                    // The wait may fail with ECHILD if another process also waited for
                    // the same pid, causing the process state to get cleaned up.
                    exited = true;
                    break;
                }
                DPLOG(ERROR) << "Error waiting for process " << process_;
            }

            usleep(sleep_ms * 1000);
            const unsigned kMaxSleepMs = 1000;
            if (sleep_ms < kMaxSleepMs)
                sleep_ms *= 2;
        }

        // If we're waiting and the child hasn't died by now, force it
        // with a SIGKILL.
        if (!exited)
            result = kill(process_, SIGKILL) == 0;
    }

    if (!result)
        DPLOG(ERROR) << "Unable to terminate process " << process_;

    return result;
}
#endif // !defined(OS_NACL_NONSFI)

bool Process::WaitForExit(int* exit_code)
{
    return WaitForExitWithTimeout(TimeDelta::Max(), exit_code);
}

bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code)
{
    return WaitForExitWithTimeoutImpl(Handle(), exit_code, timeout);
}

#if !defined(OS_LINUX)
bool Process::IsProcessBackgrounded() const
{
    // See SetProcessBackgrounded().
    DCHECK(IsValid());
    return false;
}

bool Process::SetProcessBackgrounded(bool value)
{
    // Not implemented for POSIX systems other than Linux. With POSIX, if we were
    // to lower the process priority we wouldn't be able to raise it back to its
    // initial priority.
    NOTIMPLEMENTED();
    return false;
}
#endif // !defined(OS_LINUX)

int Process::GetPriority() const
{
    DCHECK(IsValid());
    return getpriority(PRIO_PROCESS, process_);
}

} // namespace base
